+
−/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+
−/* This Source Code Form is subject to the terms of the Mozilla Public
+
− * License, v. 2.0. If a copy of the MPL was not distributed with this
+
− * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
−
+
−#include "SourceBuffer.h"
+
−
+
−#include <algorithm>
+
−#include <cmath>
+
−#include <cstring>
+
−#include "mozilla/Likely.h"
+
−#include "nsIInputStream.h"
+
−#include "MainThreadUtils.h"
+
−#include "SurfaceCache.h"
+
−
+
−using std::max;
+
−using std::min;
+
−
+
−namespace mozilla {
+
−namespace image {
+
−
+
−//////////////////////////////////////////////////////////////////////////////
+
−// SourceBufferIterator implementation.
+
−//////////////////////////////////////////////////////////////////////////////
+
−
+
−SourceBufferIterator::~SourceBufferIterator()
+
−{
+
−  if (mOwner) {
+
−    mOwner->OnIteratorRelease();
+
−  }
+
−}
+
−
+
−SourceBufferIterator&
+
−SourceBufferIterator::operator=(SourceBufferIterator&& aOther)
+
−{
+
−  if (mOwner) {
+
−    mOwner->OnIteratorRelease();
+
−  }
+
−
+
−  mOwner = Move(aOther.mOwner);
+
−  mState = aOther.mState;
+
−  mData = aOther.mData;
+
−  mChunkCount = aOther.mChunkCount;
+
−  mByteCount = aOther.mByteCount;
+
−
+
−  return *this;
+
−}
+
−
+
−SourceBufferIterator::State
+
−SourceBufferIterator::AdvanceOrScheduleResume(size_t aRequestedBytes,
+
−                                              IResumable* aConsumer)
+
−{
+
−  MOZ_ASSERT(mOwner);
+
−
+
−  if (MOZ_UNLIKELY(!HasMore())) {
+
−    MOZ_ASSERT_UNREACHABLE("Should not advance a completed iterator");
+
−    return COMPLETE;
+
−  }
+
−
+
−  // The range of data [mOffset, mOffset + mNextReadLength) has just been read
+
−  // by the caller (or at least they don't have any interest in it), so consume
+
−  // that data.
+
−  MOZ_ASSERT(mData.mIterating.mNextReadLength <= mData.mIterating.mAvailableLength);
+
−  mData.mIterating.mOffset += mData.mIterating.mNextReadLength;
+
−  mData.mIterating.mAvailableLength -= mData.mIterating.mNextReadLength;
+
−  mData.mIterating.mNextReadLength = 0;
+
−
+
−  if (MOZ_LIKELY(mState == READY)) {
+
−    // If the caller wants zero bytes of data, that's easy enough; we just
+
−    // configured ourselves for a zero-byte read above!  In theory we could do
+
−    // this even in the START state, but it's not important for performance and
+
−    // breaking the ability of callers to assert that the pointer returned by
+
−    // Data() is non-null doesn't seem worth it.
+
−    if (aRequestedBytes == 0) {
+
−      MOZ_ASSERT(mData.mIterating.mNextReadLength == 0);
+
−      return READY;
+
−    }
+
−
+
−    // Try to satisfy the request out of our local buffer. This is potentially
+
−    // much faster than requesting data from our owning SourceBuffer because we
+
−    // don't have to take the lock. Note that if we have anything at all in our
+
−    // local buffer, we use it to satisfy the request; @aRequestedBytes is just
+
−    // the *maximum* number of bytes we can return.
+
−    if (mData.mIterating.mAvailableLength > 0) {
+
−      return AdvanceFromLocalBuffer(aRequestedBytes);
+
−    }
+
−  }
+
−
+
−  // Our local buffer is empty, so we'll have to request data from our owning
+
−  // SourceBuffer.
+
−  return mOwner->AdvanceIteratorOrScheduleResume(*this,
+
−                                                 aRequestedBytes,
+
−                                                 aConsumer);
+
−}
+
−
+
−bool
+
−SourceBufferIterator::RemainingBytesIsNoMoreThan(size_t aBytes) const
+
−{
+
−  MOZ_ASSERT(mOwner);
+
−  return mOwner->RemainingBytesIsNoMoreThan(*this, aBytes);
+
−}
+
−
+
−
+
−//////////////////////////////////////////////////////////////////////////////
+
−// SourceBuffer implementation.
+
−//////////////////////////////////////////////////////////////////////////////
+
−
+
−const size_t SourceBuffer::MIN_CHUNK_CAPACITY;
+
−
+
−SourceBuffer::SourceBuffer()
+
−  : mMutex("image::SourceBuffer")
+
−  , mConsumerCount(0)
+
−{ }
+
−
+
−SourceBuffer::~SourceBuffer()
+
−{
+
−  MOZ_ASSERT(mConsumerCount == 0,
+
−             "SourceBuffer destroyed with active consumers");
+
−}
+
−
+
−nsresult
+
−SourceBuffer::AppendChunk(Maybe<Chunk>&& aChunk)
+
−{
+
−  mMutex.AssertCurrentThreadOwns();
+
−
+
−#ifdef DEBUG
+
−  if (mChunks.Length() > 0) {
+
−    NS_WARNING("Appending an extra chunk for SourceBuffer");
+
−  }
+
−#endif
+
−
+
−  if (MOZ_UNLIKELY(!aChunk)) {
+
−    return NS_ERROR_OUT_OF_MEMORY;
+
−  }
+
−
+
−  if (MOZ_UNLIKELY(aChunk->AllocationFailed())) {
+
−    return NS_ERROR_OUT_OF_MEMORY;
+
−  }
+
−
+
−  if (MOZ_UNLIKELY(!mChunks.AppendElement(Move(*aChunk), fallible))) {
+
−    return NS_ERROR_OUT_OF_MEMORY;
+
−  }
+
−
+
−  return NS_OK;
+
−}
+
−
+
−Maybe<SourceBuffer::Chunk>
+
−SourceBuffer::CreateChunk(size_t aCapacity, bool aRoundUp /* = true */)
+
−{
+
−  if (MOZ_UNLIKELY(aCapacity == 0)) {
+
−    MOZ_ASSERT_UNREACHABLE("Appending a chunk of zero size?");
+
−    return Nothing();
+
−  }
+
−
+
−  // Round up if requested.
+
−  size_t finalCapacity = aRoundUp ? RoundedUpCapacity(aCapacity)
+
−                                  : aCapacity;
+
−
+
−  // Use the size of the SurfaceCache as an additional heuristic to avoid
+
−  // allocating huge buffers. Generally images do not get smaller when decoded,
+
−  // so if we could store the source data in the SurfaceCache, we assume that
+
−  // there's no way we'll be able to store the decoded version.
+
−  if (MOZ_UNLIKELY(!SurfaceCache::CanHold(finalCapacity))) {
+
−    NS_WARNING("SourceBuffer refused to create chunk too large for SurfaceCache");
+
−    return Nothing();
+
−  }
+
−
+
−  return Some(Chunk(finalCapacity));
+
−}
+
−
+
−nsresult
+
−SourceBuffer::Compact()
+
−{
+
−  mMutex.AssertCurrentThreadOwns();
+
−
+
−  MOZ_ASSERT(mConsumerCount == 0, "Should have no consumers here");
+
−  MOZ_ASSERT(mWaitingConsumers.Length() == 0, "Shouldn't have waiters");
+
−  MOZ_ASSERT(mStatus, "Should be complete here");
+
−
+
−  // Compact our waiting consumers list, since we're complete and no future
+
−  // consumer will ever have to wait.
+
−  mWaitingConsumers.Compact();
+
−
+
−  // If we have no chunks, then there's nothing to compact.
+
−  if (mChunks.Length() < 1) {
+
−    return NS_OK;
+
−  }
+
−
+
−  // If we have one chunk, then we can compact if it has excess capacity.
+
−  if (mChunks.Length() == 1 && mChunks[0].Length() == mChunks[0].Capacity()) {
+
−    return NS_OK;
+
−  }
+
−
+
−  // We can compact our buffer. Determine the total length.
+
−  size_t length = 0;
+
−  for (uint32_t i = 0 ; i < mChunks.Length() ; ++i) {
+
−    length += mChunks[i].Length();
+
−  }
+
−
+
−  // If our total length is zero (which means ExpectLength() got called, but no
+
−  // data ever actually got written) then just empty our chunk list.
+
−  if (MOZ_UNLIKELY(length == 0)) {
+
−    mChunks.Clear();
+
−    return NS_OK;
+
−  }
+
−
+
−  Maybe<Chunk> newChunk = CreateChunk(length, /* aRoundUp = */ false);
+
−  if (MOZ_UNLIKELY(!newChunk || newChunk->AllocationFailed())) {
+
−    NS_WARNING("Failed to allocate chunk for SourceBuffer compacting - OOM?");
+
−    return NS_OK;
+
−  }
+
−
+
−  // Copy our old chunks into the new chunk.
+
−  for (uint32_t i = 0 ; i < mChunks.Length() ; ++i) {
+
−    size_t offset = newChunk->Length();
+
−    MOZ_ASSERT(offset < newChunk->Capacity());
+
−    MOZ_ASSERT(offset + mChunks[i].Length() <= newChunk->Capacity());
+
−
+
−    memcpy(newChunk->Data() + offset, mChunks[i].Data(), mChunks[i].Length());
+
−    newChunk->AddLength(mChunks[i].Length());
+
−  }
+
−
+
−  MOZ_ASSERT(newChunk->Length() == newChunk->Capacity(),
+
−             "Compacted chunk has slack space");
+
−
+
−  // Replace the old chunks with the new, compact chunk.
+
−  mChunks.Clear();
+
−  if (MOZ_UNLIKELY(NS_FAILED(AppendChunk(Move(newChunk))))) {
+
−    return HandleError(NS_ERROR_OUT_OF_MEMORY);
+
−  }
+
−  mChunks.Compact();
+
−
+
−  return NS_OK;
+
−}
+
−
+
−/* static */ size_t
+
−SourceBuffer::RoundedUpCapacity(size_t aCapacity)
+
−{
+
−  // Protect against overflow.
+
−  if (MOZ_UNLIKELY(SIZE_MAX - aCapacity < MIN_CHUNK_CAPACITY)) {
+
−    return aCapacity;
+
−  }
+
−
+
−  // Round up to the next multiple of MIN_CHUNK_CAPACITY (which should be the
+
−  // size of a page).
+
−  size_t roundedCapacity =
+
−    (aCapacity + MIN_CHUNK_CAPACITY - 1) & ~(MIN_CHUNK_CAPACITY - 1);
+
−  MOZ_ASSERT(roundedCapacity >= aCapacity, "Bad math?");
+
−  MOZ_ASSERT(roundedCapacity - aCapacity < MIN_CHUNK_CAPACITY, "Bad math?");
+
−
+
−  return roundedCapacity;
+
−}
+
−
+
−size_t
+
−SourceBuffer::FibonacciCapacityWithMinimum(size_t aMinCapacity)
+
−{
+
−  mMutex.AssertCurrentThreadOwns();
+
−
+
−  // We grow the source buffer using a Fibonacci growth rate.
+
−
+
−  size_t length = mChunks.Length();
+
−
+
−  if (length == 0) {
+
−    return aMinCapacity;
+
−  }
+
−
+
−  if (length == 1) {
+
−    return max(2 * mChunks[0].Capacity(), aMinCapacity);
+
−  }
+
−
+
−  return max(mChunks[length - 1].Capacity() + mChunks[length - 2].Capacity(),
+
−             aMinCapacity);
+
−}
+
−
+
−void
+
−SourceBuffer::AddWaitingConsumer(IResumable* aConsumer)
+
−{
+
−  mMutex.AssertCurrentThreadOwns();
+
−
+
−  MOZ_ASSERT(!mStatus, "Waiting when we're complete?");
+
−
+
−  if (aConsumer) {
+
−    mWaitingConsumers.AppendElement(aConsumer);
+
−  }
+
−}
+
−
+
−void
+
−SourceBuffer::ResumeWaitingConsumers()
+
−{
+
−  mMutex.AssertCurrentThreadOwns();
+
−
+
−  if (mWaitingConsumers.Length() == 0) {
+
−    return;
+
−  }
+
−
+
−  for (uint32_t i = 0 ; i < mWaitingConsumers.Length() ; ++i) {
+
−    mWaitingConsumers[i]->Resume();
+
−  }
+
−
+
−  mWaitingConsumers.Clear();
+
−}
+
−
+
−nsresult
+
−SourceBuffer::ExpectLength(size_t aExpectedLength)
+
−{
+
−  MOZ_ASSERT(aExpectedLength > 0, "Zero expected size?");
+
−
+
−  MutexAutoLock lock(mMutex);
+
−
+
−  if (MOZ_UNLIKELY(mStatus)) {
+
−    MOZ_ASSERT_UNREACHABLE("ExpectLength after SourceBuffer is complete");
+
−    return NS_OK;
+
−  }
+
−
+
−  if (MOZ_UNLIKELY(mChunks.Length() > 0)) {
+
−    MOZ_ASSERT_UNREACHABLE("Duplicate or post-Append call to ExpectLength");
+
−    return NS_OK;
+
−  }
+
−
+
−  if (MOZ_UNLIKELY(NS_FAILED(AppendChunk(CreateChunk(aExpectedLength))))) {
+
−    return HandleError(NS_ERROR_OUT_OF_MEMORY);
+
−  }
+
−
+
−  return NS_OK;
+
−}
+
−
+
−nsresult
+
−SourceBuffer::Append(const char* aData, size_t aLength)
+
−{
+
−  MOZ_ASSERT(aData, "Should have a buffer");
+
−  MOZ_ASSERT(aLength > 0, "Writing a zero-sized chunk");
+
−
+
−  size_t currentChunkCapacity = 0;
+
−  size_t currentChunkLength = 0;
+
−  char* currentChunkData = nullptr;
+
−  size_t currentChunkRemaining = 0;
+
−  size_t forCurrentChunk = 0;
+
−  size_t forNextChunk = 0;
+
−  size_t nextChunkCapacity = 0;
+
−
+
−  {
+
−    MutexAutoLock lock(mMutex);
+
−
+
−    if (MOZ_UNLIKELY(mStatus)) {
+
−      // This SourceBuffer is already complete; ignore further data.
+
−      return NS_ERROR_FAILURE;
+
−    }
+
−
+
−    if (MOZ_UNLIKELY(mChunks.Length() == 0)) {
+
−      if (MOZ_UNLIKELY(NS_FAILED(AppendChunk(CreateChunk(aLength))))) {
+
−        return HandleError(NS_ERROR_OUT_OF_MEMORY);
+
−      }
+
−    }
+
−
+
−    // Copy out the current chunk's information so we can release the lock.
+
−    // Note that this wouldn't be safe if multiple producers were allowed!
+
−    Chunk& currentChunk = mChunks.LastElement();
+
−    currentChunkCapacity = currentChunk.Capacity();
+
−    currentChunkLength = currentChunk.Length();
+
−    currentChunkData = currentChunk.Data();
+
−
+
−    // Partition this data between the current chunk and the next chunk.
+
−    // (Because we always allocate a chunk big enough to fit everything passed
+
−    // to Append, we'll never need more than those two chunks to store
+
−    // everything.)
+
−    currentChunkRemaining = currentChunkCapacity - currentChunkLength;
+
−    forCurrentChunk = min(aLength, currentChunkRemaining);
+
−    forNextChunk = aLength - forCurrentChunk;
+
−
+
−    // If we'll need another chunk, determine what its capacity should be while
+
−    // we still hold the lock.
+
−    nextChunkCapacity = forNextChunk > 0
+
−                      ? FibonacciCapacityWithMinimum(forNextChunk)
+
−                      : 0;
+
−  }
+
−
+
−  // Write everything we can fit into the current chunk.
+
−  MOZ_ASSERT(currentChunkLength + forCurrentChunk <= currentChunkCapacity);
+
−  memcpy(currentChunkData + currentChunkLength, aData, forCurrentChunk);
+
−
+
−  // If there's something left, create a new chunk and write it there.
+
−  Maybe<Chunk> nextChunk;
+
−  if (forNextChunk > 0) {
+
−    MOZ_ASSERT(nextChunkCapacity >= forNextChunk, "Next chunk too small?");
+
−    nextChunk = CreateChunk(nextChunkCapacity);
+
−    if (MOZ_LIKELY(nextChunk && !nextChunk->AllocationFailed())) {
+
−      memcpy(nextChunk->Data(), aData + forCurrentChunk, forNextChunk);
+
−      nextChunk->AddLength(forNextChunk);
+
−    }
+
−  }
+
−
+
−  // Update shared data structures.
+
−  {
+
−    MutexAutoLock lock(mMutex);
+
−
+
−    // Update the length of the current chunk.
+
−    Chunk& currentChunk = mChunks.LastElement();
+
−    MOZ_ASSERT(currentChunk.Data() == currentChunkData, "Multiple producers?");
+
−    MOZ_ASSERT(currentChunk.Length() == currentChunkLength,
+
−               "Multiple producers?");
+
−
+
−    currentChunk.AddLength(forCurrentChunk);
+
−
+
−    // If we created a new chunk, add it to the series.
+
−    if (forNextChunk > 0) {
+
−      if (MOZ_UNLIKELY(!nextChunk)) {
+
−        return HandleError(NS_ERROR_OUT_OF_MEMORY);
+
−      }
+
−
+
−      if (MOZ_UNLIKELY(NS_FAILED(AppendChunk(Move(nextChunk))))) {
+
−        return HandleError(NS_ERROR_OUT_OF_MEMORY);
+
−      }
+
−    }
+
−
+
−    // Resume any waiting readers now that there's new data.
+
−    ResumeWaitingConsumers();
+
−  }
+
−
+
−  return NS_OK;
+
−}
+
−
+
−static nsresult
+
−AppendToSourceBuffer(nsIInputStream*,
+
−                     void* aClosure,
+
−                     const char* aFromRawSegment,
+
−                     uint32_t,
+
−                     uint32_t aCount,
+
−                     uint32_t* aWriteCount)
+
−{
+
−  SourceBuffer* sourceBuffer = static_cast<SourceBuffer*>(aClosure);
+
−
+
−  // Copy the source data. Unless we hit OOM, we squelch the return value here,
+
−  // because returning an error means that ReadSegments stops reading data, and
+
−  // we want to ensure that we read everything we get. If we hit OOM then we
+
−  // return a failed status to the caller.
+
−  nsresult rv = sourceBuffer->Append(aFromRawSegment, aCount);
+
−  if (rv == NS_ERROR_OUT_OF_MEMORY) {
+
−    return rv;
+
−  }
+
−
+
−  // Report that we wrote everything we got.
+
−  *aWriteCount = aCount;
+
−
+
−  return NS_OK;
+
−}
+
−
+
−nsresult
+
−SourceBuffer::AppendFromInputStream(nsIInputStream* aInputStream,
+
−                                    uint32_t aCount)
+
−{
+
−  uint32_t bytesRead;
+
−  nsresult rv = aInputStream->ReadSegments(AppendToSourceBuffer, this,
+
−                                           aCount, &bytesRead);
+
−  if (!NS_WARN_IF(NS_FAILED(rv))) {
+
−    MOZ_ASSERT(bytesRead == aCount,
+
−               "AppendToSourceBuffer should consume everything");
+
−  }
+
−  return rv;
+
−}
+
−
+
−void
+
−SourceBuffer::Complete(nsresult aStatus)
+
−{
+
−  MutexAutoLock lock(mMutex);
+
−
+
−  if (MOZ_UNLIKELY(mStatus)) {
+
−    MOZ_ASSERT_UNREACHABLE("Called Complete more than once");
+
−    return;
+
−  }
+
−
+
−  if (MOZ_UNLIKELY(NS_SUCCEEDED(aStatus) && IsEmpty())) {
+
−    // It's illegal to succeed without writing anything.
+
−    aStatus = NS_ERROR_FAILURE;
+
−  }
+
−
+
−  mStatus = Some(aStatus);
+
−
+
−  // Resume any waiting consumers now that we're complete.
+
−  ResumeWaitingConsumers();
+
−
+
−  // If we still have active consumers, just return.
+
−  if (mConsumerCount > 0) {
+
−    return;
+
−  }
+
−
+
−  // Attempt to compact our buffer down to a single chunk.
+
−  Compact();
+
−}
+
−
+
−bool
+
−SourceBuffer::IsComplete()
+
−{
+
−  MutexAutoLock lock(mMutex);
+
−  return bool(mStatus);
+
−}
+
−
+
−size_t
+
−SourceBuffer::SizeOfIncludingThisWithComputedFallback(MallocSizeOf
+
−                                                        aMallocSizeOf) const
+
−{
+
−  MutexAutoLock lock(mMutex);
+
−
+
−  size_t n = aMallocSizeOf(this);
+
−  n += mChunks.ShallowSizeOfExcludingThis(aMallocSizeOf);
+
−
+
−  for (uint32_t i = 0 ; i < mChunks.Length() ; ++i) {
+
−    size_t chunkSize = aMallocSizeOf(mChunks[i].Data());
+
−
+
−    if (chunkSize == 0) {
+
−      // We're on a platform where moz_malloc_size_of always returns 0.
+
−      chunkSize = mChunks[i].Capacity();
+
−    }
+
−
+
−    n += chunkSize;
+
−  }
+
−
+
−  return n;
+
−}
+
−
+
−SourceBufferIterator
+
−SourceBuffer::Iterator()
+
−{
+
−  {
+
−    MutexAutoLock lock(mMutex);
+
−    mConsumerCount++;
+
−  }
+
−
+
−  return SourceBufferIterator(this);
+
−}
+
−
+
−void
+
−SourceBuffer::OnIteratorRelease()
+
−{
+
−  MutexAutoLock lock(mMutex);
+
−
+
−  MOZ_ASSERT(mConsumerCount > 0, "Consumer count doesn't add up");
+
−  mConsumerCount--;
+
−
+
−  // If we still have active consumers, or we're not complete yet, then return.
+
−  if (mConsumerCount > 0 || !mStatus) {
+
−    return;
+
−  }
+
−
+
−  // Attempt to compact our buffer down to a single chunk.
+
−  Compact();
+
−}
+
−
+
−bool
+
−SourceBuffer::RemainingBytesIsNoMoreThan(const SourceBufferIterator& aIterator,
+
−                                         size_t aBytes) const
+
−{
+
−  MutexAutoLock lock(mMutex);
+
−
+
−  // If we're not complete, we always say no.
+
−  if (!mStatus) {
+
−    return false;
+
−  }
+
−
+
−  // If the iterator's at the end, the answer is trivial.
+
−  if (!aIterator.HasMore()) {
+
−    return true;
+
−  }
+
−
+
−  uint32_t iteratorChunk = aIterator.mData.mIterating.mChunk;
+
−  size_t iteratorOffset = aIterator.mData.mIterating.mOffset;
+
−  size_t iteratorLength = aIterator.mData.mIterating.mAvailableLength;
+
−
+
−  // Include the bytes the iterator is currently pointing to in the limit, so
+
−  // that the current chunk doesn't have to be a special case.
+
−  size_t bytes = aBytes + iteratorOffset + iteratorLength;
+
−
+
−  // Count the length over all of our chunks, starting with the one that the
+
−  // iterator is currently pointing to. (This is O(N), but N is expected to be
+
−  // ~1, so it doesn't seem worth caching the length separately.)
+
−  size_t lengthSoFar = 0;
+
−  for (uint32_t i = iteratorChunk ; i < mChunks.Length() ; ++i) {
+
−    lengthSoFar += mChunks[i].Length();
+
−    if (lengthSoFar > bytes) {
+
−      return false;
+
−    }
+
−  }
+
−
+
−  return true;
+
−}
+
−
+
−SourceBufferIterator::State
+
−SourceBuffer::AdvanceIteratorOrScheduleResume(SourceBufferIterator& aIterator,
+
−                                              size_t aRequestedBytes,
+
−                                              IResumable* aConsumer)
+
−{
+
−  MutexAutoLock lock(mMutex);
+
−
+
−  MOZ_ASSERT(aIterator.HasMore(), "Advancing a completed iterator and "
+
−                                  "AdvanceOrScheduleResume didn't catch it");
+
−
+
−  if (MOZ_UNLIKELY(mStatus && NS_FAILED(*mStatus))) {
+
−    // This SourceBuffer is complete due to an error; all reads fail.
+
−    return aIterator.SetComplete(*mStatus);
+
−  }
+
−
+
−  if (MOZ_UNLIKELY(mChunks.Length() == 0)) {
+
−    // We haven't gotten an initial chunk yet.
+
−    AddWaitingConsumer(aConsumer);
+
−    return aIterator.SetWaiting();
+
−  }
+
−
+
−  uint32_t iteratorChunkIdx = aIterator.mData.mIterating.mChunk;
+
−  MOZ_ASSERT(iteratorChunkIdx < mChunks.Length());
+
−
+
−  const Chunk& currentChunk = mChunks[iteratorChunkIdx];
+
−  size_t iteratorEnd = aIterator.mData.mIterating.mOffset +
+
−                       aIterator.mData.mIterating.mAvailableLength;
+
−  MOZ_ASSERT(iteratorEnd <= currentChunk.Length());
+
−  MOZ_ASSERT(iteratorEnd <= currentChunk.Capacity());
+
−
+
−  if (iteratorEnd < currentChunk.Length()) {
+
−    // There's more data in the current chunk.
+
−    return aIterator.SetReady(iteratorChunkIdx, currentChunk.Data(),
+
−                              iteratorEnd, currentChunk.Length() - iteratorEnd,
+
−                              aRequestedBytes);
+
−  }
+
−
+
−  if (iteratorEnd == currentChunk.Capacity() &&
+
−      !IsLastChunk(iteratorChunkIdx)) {
+
−    // Advance to the next chunk.
+
−    const Chunk& nextChunk = mChunks[iteratorChunkIdx + 1];
+
−    return aIterator.SetReady(iteratorChunkIdx + 1, nextChunk.Data(), 0,
+
−                              nextChunk.Length(), aRequestedBytes);
+
−  }
+
−
+
−  MOZ_ASSERT(IsLastChunk(iteratorChunkIdx), "Should've advanced");
+
−
+
−  if (mStatus) {
+
−    // There's no more data and this SourceBuffer completed successfully.
+
−    MOZ_ASSERT(NS_SUCCEEDED(*mStatus), "Handled failures earlier");
+
−    return aIterator.SetComplete(*mStatus);
+
−  }
+
−
+
−  // We're not complete, but there's no more data right now. Arrange to wake up
+
−  // the consumer when we get more data.
+
−  AddWaitingConsumer(aConsumer);
+
−  return aIterator.SetWaiting();
+
−}
+
−
+
−nsresult
+
−SourceBuffer::HandleError(nsresult aError)
+
−{
+
−  MOZ_ASSERT(NS_FAILED(aError), "Should have an error here");
+
−  MOZ_ASSERT(aError == NS_ERROR_OUT_OF_MEMORY,
+
−             "Unexpected error; may want to notify waiting readers, which "
+
−             "HandleError currently doesn't do");
+
−
+
−  mMutex.AssertCurrentThreadOwns();
+
−
+
−  NS_WARNING("SourceBuffer encountered an unrecoverable error");
+
−
+
−  // Record the error.
+
−  mStatus = Some(aError);
+
−
+
−  // Drop our references to waiting readers.
+
−  mWaitingConsumers.Clear();
+
−
+
−  return *mStatus;
+
−}
+
−
+
−bool
+
−SourceBuffer::IsEmpty()
+
−{
+
−  mMutex.AssertCurrentThreadOwns();
+
−  return mChunks.Length() == 0 ||
+
−         mChunks[0].Length() == 0;
+
−}
+
−
+
−bool
+
−SourceBuffer::IsLastChunk(uint32_t aChunk)
+
−{
+
−  mMutex.AssertCurrentThreadOwns();
+
−  return aChunk + 1 == mChunks.Length();
+
−}
+
−
+
−} // namespace image
+
−} // namespace mozilla